// WebSocket连接管理模块
const WebSocketManager = {
  ws: null,
  userId: null,
  reconnectAttempts: 0,
  maxReconnectAttempts: 5,
  reconnectInterval: 3000,
  reconnectTimer: null,
  messageHandlers: {},
  connectionCallbacks: {}
};

/**
 * 初始化WebSocket连接
 * @param {string} userId - 用户ID，将用作WebSocket连接的sid参数
 * @param {Object} callbacks - 回调函数对象
 */
function initWebSocket(userId, callbacks = {}) {
  // 存储用户ID
  WebSocketManager.userId = userId;
  
  // 存储回调函数
  WebSocketManager.connectionCallbacks = {
    onConnect: callbacks.onConnect || function() {},
    onDisconnect: callbacks.onDisconnect || function() {},
    onError: callbacks.onError || function() {},
    onMessage: callbacks.onMessage || function() {}
  };
  
  // 连接WebSocket
  connectWebSocket();
  
  // 监听页面关闭事件，确保断开WebSocket连接
  window.addEventListener('beforeunload', function() {
    disconnectWebSocket();
  });
}

/**
 * 建立WebSocket连接
 */
function connectWebSocket() {
  if (!WebSocketManager.userId) {
    console.error('WebSocket: 用户ID未设置，无法建立连接');
    return;
  }
  
  try {
    // 获取当前页面协议，自动切换ws/wss
    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
    // 获取当前主机和端口
    const host = window.location.host;
    // 构建WebSocket连接URL
    const wsUrl = `${protocol}//${host}/ws/${WebSocketManager.userId}`;
    
    console.log(`WebSocket: 正在连接到 ${wsUrl}`);
    
    // 创建WebSocket实例
    WebSocketManager.ws = new WebSocket(wsUrl);
    
    // 设置WebSocket事件处理器
    WebSocketManager.ws.onopen = handleWebSocketOpen;
    WebSocketManager.ws.onmessage = handleWebSocketMessage;
    WebSocketManager.ws.onclose = handleWebSocketClose;
    WebSocketManager.ws.onerror = handleWebSocketError;
    
  } catch (error) {
    console.error(`WebSocket: 连接失败: ${error.message}`);
    WebSocketManager.connectionCallbacks.onError(error);
    
    // 尝试重连
    scheduleReconnect();
  }
}

/**
 * 断开WebSocket连接
 */
function disconnectWebSocket() {
  // 清除重连定时器
  if (WebSocketManager.reconnectTimer) {
    clearTimeout(WebSocketManager.reconnectTimer);
    WebSocketManager.reconnectTimer = null;
  }
  
  // 重置重连计数
  WebSocketManager.reconnectAttempts = 0;
  
  // 关闭WebSocket连接
  if (WebSocketManager.ws) {
    WebSocketManager.ws.close();
    WebSocketManager.ws = null;
  }
}

/**
 * 发送消息到服务器
 * @param {string} message - 要发送的消息
 */
function sendWebSocketMessage(message) {
  if (WebSocketManager.ws && WebSocketManager.ws.readyState === WebSocket.OPEN) {
    WebSocketManager.ws.send(message);
    return true;
  } else {
    console.error('WebSocket: 连接未建立，无法发送消息');
    return false;
  }
}

/**
 * 注册消息处理器
 * @param {string} messageType - 消息类型
 * @param {Function} handler - 消息处理函数
 */
function registerWebSocketMessageHandler(messageType, handler) {
  if (typeof handler === 'function') {
    WebSocketManager.messageHandlers[messageType] = handler;
  }
}

/**
 * WebSocket连接建立事件处理器
 */
function handleWebSocketOpen() {
  console.log('WebSocket: 连接已成功建立');
  
  // 重置重连计数
  WebSocketManager.reconnectAttempts = 0;
  
  // 调用连接成功回调
  WebSocketManager.connectionCallbacks.onConnect();
}

/**
 * WebSocket消息接收事件处理器
 * @param {MessageEvent} event - 消息事件对象
 */
function handleWebSocketMessage(event) {
  try {
    // 尝试解析JSON消息
    let messageData = event.data;
    let parsedData = null;
    
    // 尝试将消息解析为JSON对象
    try {
      parsedData = JSON.parse(messageData);
    } catch (jsonError) {
      // 如果不是JSON格式，直接传递原始消息
      parsedData = messageData;
    }
    
    console.log('WebSocket: 收到消息:', parsedData);
    
    // 处理订单提醒消息
    if (typeof parsedData === 'object' && parsedData !== null) {
      // 检查是否为订单提醒消息
      if (parsedData.type === 1 && parsedData.orderId) {
        handleOrderNotification(parsedData);
      }
      
      // 调用特定类型的消息处理器
      if (parsedData.type && WebSocketManager.messageHandlers[parsedData.type]) {
        WebSocketManager.messageHandlers[parsedData.type](parsedData);
      }
    }
    
    // 调用通用消息回调
    WebSocketManager.connectionCallbacks.onMessage(parsedData);
    
  } catch (error) {
    console.error(`WebSocket: 处理消息时发生错误: ${error.message}`);
  }
}

/**
 * WebSocket连接关闭事件处理器
 */
function handleWebSocketClose() {
  console.log('WebSocket: 连接已关闭');
  
  // 调用断开连接回调
  WebSocketManager.connectionCallbacks.onDisconnect();
  
  // 尝试重连（如果不是手动关闭）
  if (WebSocketManager.reconnectAttempts < WebSocketManager.maxReconnectAttempts) {
    scheduleReconnect();
  }
}

/**
 * WebSocket连接错误事件处理器
 */
function handleWebSocketError(error) {
  console.error(`WebSocket: 连接发生错误: ${error.message || '未知错误'}`);
  
  // 调用错误回调
  WebSocketManager.connectionCallbacks.onError(error);
}

/**
 * 安排重连
 */
function scheduleReconnect() {
  // 避免重复设置重连定时器
  if (WebSocketManager.reconnectTimer) {
    return;
  }
  
  // 增加重连计数
  WebSocketManager.reconnectAttempts++;
  
  if (WebSocketManager.reconnectAttempts > WebSocketManager.maxReconnectAttempts) {
    console.error(`WebSocket: 重连次数已达上限(${WebSocketManager.maxReconnectAttempts})，停止重连`);
    return;
  }
  
  const delay = WebSocketManager.reconnectInterval * Math.pow(2, WebSocketManager.reconnectAttempts - 1);
  console.log(`WebSocket: ${delay}毫秒后尝试第${WebSocketManager.reconnectAttempts}次重连`);
  
  WebSocketManager.reconnectTimer = setTimeout(() => {
    WebSocketManager.reconnectTimer = null;
    connectWebSocket();
  }, delay);
}

/**
 * 处理订单提醒消息
 * @param {Object} message - 订单提醒消息对象
 */
function handleOrderNotification(message) {
  console.log('WebSocket: 收到订单提醒:', message);
  
  // 这里可以根据实际业务需求实现订单提醒的处理逻辑
  // 例如：显示通知、播放提示音、更新订单列表等
  
  // 示例：显示浏览器通知
  if (Notification.permission === 'granted') {
    new Notification('新订单提醒', {
      body: `订单号: ${message.orderNumber || message.orderId}\n请及时处理！`,
      icon: '/favicon.ico',
      tag: 'order-notification'
    });
  }
  
  // 这里可以添加其他订单提醒处理逻辑
}

/**
 * 请求浏览器通知权限
 */
function requestNotificationPermission() {
  if ('Notification' in window && Notification.permission !== 'granted') {
    Notification.requestPermission().then(permission => {
      if (permission === 'granted') {
        console.log('WebSocket: 已获得浏览器通知权限');
      }
    });
  }
}

/**
 * 登录成功后初始化WebSocket连接的示例函数
 * 这个函数可以在用户登录成功后调用
 */
function initWebSocketAfterLogin() {
  // 从登录信息中获取用户ID
  // 这里假设用户ID存储在localStorage中
  const userId = localStorage.getItem('userId') || 'user_' + Date.now();
  
  // 请求通知权限
  requestNotificationPermission();
  
  // 初始化WebSocket连接
  initWebSocket(userId, {
    onConnect: function() {
      console.log('WebSocket: 连接成功，已可以接收实时消息');
      // 可以在这里添加连接成功后的处理逻辑
    },
    onDisconnect: function() {
      console.log('WebSocket: 连接已断开');
      // 可以在这里添加连接断开后的处理逻辑
    },
    onError: function(error) {
      console.error('WebSocket: 连接错误:', error);
      // 可以在这里添加错误处理逻辑
    },
    onMessage: function(message) {
      // 通用消息处理
      console.log('WebSocket: 接收到消息:', message);
    }
  });
}

/**
 * 导出WebSocket管理相关函数和对象，供其他模块使用
 */
window.WebSocketManager = {
  init: initWebSocket,
  disconnect: disconnectWebSocket,
  send: sendWebSocketMessage,
  registerHandler: registerWebSocketMessageHandler,
  initAfterLogin: initWebSocketAfterLogin
};